home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 August: Tool Chest / Dev.CD Aug 98 TC.toast / Sample Code / Text / SimpleText Sample / PICTFile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-10-17  |  21.2 KB  |  766 lines  |  [TEXT/MPS ]
  1. /*
  2.     File:        PICTFile.c
  3.  
  4.     Contains:    PICT file for simple text application
  5.  
  6.     Version:    SimpleText 1.4 or later
  7.  
  8. ** Copyright 1993-1996 Apple Computer. All rights reserved.
  9. **
  10. **    You may incorporate this sample code into your applications without
  11. **    restriction, though the sample code has been provided "AS IS" and the
  12. **    responsibility for its operation is 100% yours.  However, what you are
  13. **    not permitted to do is to redistribute the source as "DSC Sample Code"
  14. **    after having made changes. If you're going to re-distribute the source,
  15. **    we require that you make it clear in the source that the code was
  16. **    descended from Apple Sample Code, but that you've made changes.
  17.  
  18. */
  19.  
  20. #include "MacIncludes.h"
  21.  
  22. #include "PICTFile.h"
  23.  
  24. /* ------------------------------------------------------------------------------------    */
  25. /* GLOBALS ONLY USED BY THIS FILE */
  26. /* ------------------------------------------------------------------------------------    */
  27. #define kBufferSize    2048
  28.  
  29. static short            gPictFileRefNum;
  30. static char                gPictureBuffer[kBufferSize];
  31. static long                gAmountInBuffer;
  32. static long                gFirstCharInBuffer;
  33. static QDProcsPtr         gSavedProcs;
  34. static QDProcs            gMyProcs;
  35. static CQDProcs           gMyColorProcs;
  36.  
  37. // --------------------------------------------------------------------------------------------------------------
  38. // INTERNAL ROUTINES
  39. // --------------------------------------------------------------------------------------------------------------
  40.  
  41. static pascal void GetPICTData(Ptr dataPtr,short byteCount)
  42. /*
  43.     replacement for the QuickDraw bottleneck routine
  44. */
  45. { 
  46.     OSErr            err = noErr;
  47.     long            longCount;
  48.  
  49.     longCount = byteCount;
  50.     
  51.     while ( (longCount > 0) && (err == noErr) )
  52.         {
  53.         if (gAmountInBuffer == 0)
  54.             {
  55.             gAmountInBuffer = kBufferSize;
  56.             gFirstCharInBuffer = 0;
  57.             err = FSRead(gPictFileRefNum,&gAmountInBuffer,gPictureBuffer);
  58.             }
  59.  
  60.         if (gAmountInBuffer > 0)
  61.             {
  62.             long    amountToMove;
  63.             
  64.             amountToMove = gAmountInBuffer;
  65.             if (amountToMove > longCount)
  66.                 amountToMove = longCount;
  67.                 
  68.             BlockMoveData(&gPictureBuffer[gFirstCharInBuffer], dataPtr, amountToMove);
  69.             longCount -= amountToMove;
  70.             dataPtr += amountToMove;
  71.             gFirstCharInBuffer += amountToMove;
  72.             gAmountInBuffer -= amountToMove;
  73.             }
  74.             
  75.         }
  76.     
  77. } // GetPICTData
  78.  
  79. #if GENERATINGCFM
  80.     static RoutineDescriptor gGetPICTDataRD = BUILD_ROUTINE_DESCRIPTOR(uppQDGetPicProcInfo, GetPICTData);
  81.     static QDGetPicUPP gGetPICTData = &gGetPICTDataRD;
  82. #else
  83.     static QDGetPicUPP gGetPICTData = NewQDGetPicProc(GetPICTData);
  84. #endif
  85.  
  86. // --------------------------------------------------------------------------------------------------------------
  87.  
  88. static OSErr    DiskPictureDraw( WindowDataPtr pData, 
  89.     Boolean doDraw, Rect *pictureRect, Point *pOffset)
  90. {
  91.  
  92.     OSErr        anErr;
  93.     PicHandle    picHandle;
  94.     Point        offset;
  95.     
  96.     if (pOffset)
  97.         offset = *pOffset;
  98.     else
  99.         {
  100.         offset.h = GetControlValue(pData->hScroll);
  101.         offset.v = GetControlValue(pData->vScroll);
  102.         }
  103.  
  104.     picHandle = ((PICTDataPtr)pData)->cacheHandle;
  105.     
  106.     if (picHandle)
  107.         {
  108.  
  109.  
  110.         if (doDraw)
  111.             {
  112.             Rect    destRect;
  113.             
  114.             GetPICTRectangleAt72dpi(picHandle, &destRect);
  115.  
  116.             OffsetRect(&destRect, 
  117.                                 -destRect.left + 
  118.                                     pData->contentRect.left -
  119.                                     offset.h, 
  120.                                 -destRect.top + 
  121.                                     pData->contentRect.top -
  122.                                     offset.v);
  123.             DrawPicture(picHandle, &destRect);
  124.             }
  125.         
  126.         if (pictureRect)
  127.             {
  128.             GetPICTRectangleAt72dpi(picHandle, pictureRect);
  129.             OffsetRect(pictureRect, -pictureRect->left, -pictureRect->top);
  130.             }
  131.             
  132.         picHandle = nil;
  133.         anErr = noErr;
  134.         }
  135.     else
  136.         {
  137.         // make enough room for PICT header, including version
  138.         picHandle = (PicHandle) NewHandle(sizeof(Picture)  + sizeof(long)*8);
  139.         anErr = MemError();
  140.         nrequire(anErr, FailedNewHandle);
  141.         
  142.         gPictFileRefNum = pData->dataRefNum;
  143.         anErr = SetFPos(gPictFileRefNum, fsFromStart, 512);
  144.         nrequire(anErr, FailedSetFPos);
  145.         
  146.         gAmountInBuffer = kBufferSize;
  147.         gFirstCharInBuffer = 0;
  148.         anErr = FSRead(gPictFileRefNum, &gAmountInBuffer, gPictureBuffer);
  149.         if (anErr == eofErr)
  150.             anErr = noErr;
  151.         if (gAmountInBuffer < sizeof(Picture))
  152.             anErr = eofErr;
  153.         nrequire(anErr, FailedInitialRead);
  154.     
  155.         // copy PICT header, including version
  156.         BlockMoveData(gPictureBuffer, *picHandle, sizeof(Picture) + sizeof(long)*8);
  157.         gFirstCharInBuffer += sizeof(Picture);
  158.         gAmountInBuffer -= sizeof(Picture);
  159.         
  160.         if (doDraw)
  161.             {
  162.             Rect    destRect;
  163.             
  164.             GetPICTRectangleAt72dpi(picHandle, &destRect);
  165.             if (!gMachineInfo.haveQuickTime)
  166.                 {
  167.                 if (gMachineInfo.theEnvirons.hasColorQD)
  168.                     {
  169.                     if ((*qd.thePort).grafProcs)
  170.                         BlockMoveData((*qd.thePort).grafProcs, &gMyColorProcs, sizeof(gMyColorProcs));
  171.                     else
  172.                         SetStdCProcs(&gMyColorProcs);
  173.                     }
  174.                 else
  175.                     {
  176.                     if ((*qd.thePort).grafProcs)
  177.                         BlockMoveData((*qd.thePort).grafProcs, &gMyProcs, sizeof(gMyProcs));
  178.                     else
  179.                         SetStdProcs(&gMyProcs);
  180.                     }
  181.                     
  182.                 gMyProcs.getPicProc = gGetPICTData;
  183.                 gMyColorProcs.getPicProc = gGetPICTData;
  184.                 gSavedProcs = (*qd.thePort).grafProcs;
  185.             
  186.                 if (gMachineInfo.theEnvirons.hasColorQD)
  187.                     (*qd.thePort).grafProcs = (QDProcsPtr)&gMyColorProcs;
  188.                 else
  189.                     (*qd.thePort).grafProcs = &gMyProcs;
  190.                 }
  191.                 
  192.             OffsetRect(&destRect, 
  193.                                 -destRect.left + 
  194.                                     pData->contentRect.left -
  195.                                     offset.h, 
  196.                                 -destRect.top + 
  197.                                     pData->contentRect.top -
  198.                                     offset.v);
  199.                                                 
  200.             if (!gMachineInfo.haveQuickTime)
  201.                 {
  202.                 DrawPicture(picHandle, &destRect);
  203.                 (*qd.thePort).grafProcs = gSavedProcs;
  204.                 }
  205.             else
  206.                 DrawPictureFile(gPictFileRefNum, &destRect, nil);
  207.     
  208.             }
  209.             
  210.         if (pictureRect)
  211.             {
  212.             GetPICTRectangleAt72dpi(picHandle, pictureRect);
  213.             OffsetRect(pictureRect, -pictureRect->left, -pictureRect->top);
  214.             }
  215.         }
  216.     
  217. // FALL THROUGH EXCEPTION HANDLING
  218. FailedInitialRead:
  219. FailedSetFPos:
  220.     DisposeHandle((Handle) picHandle);
  221.  
  222. FailedNewHandle:
  223.     
  224.     return(anErr);
  225.         
  226. } // DiskPictureDraw
  227.  
  228. // --------------------------------------------------------------------------------------------------------------
  229. static OSErr GetSelectedPicture(WindowDataPtr pData, PicHandle *pResult)
  230. {
  231.     OSErr        anErr;
  232.     PicHandle    scrapPict;
  233.     Rect        globRect;
  234.     GDHandle    theMaxDevice;
  235.     short        theDepth;
  236.     GDHandle    savedGDevice;
  237.     CGrafPtr    savedPort;
  238.     GWorldPtr    offscreenGWorld;
  239.  
  240.     // save away current value for restores
  241.     GetGWorld(&savedPort, &savedGDevice);
  242.  
  243.     // determine the best way in which to allocate stuff
  244.     
  245.     SetRect(&globRect, -32760, -32760, 32760, 32760);
  246.     theDepth = 1;
  247.     if (gMachineInfo.theEnvirons.hasColorQD)
  248.         {
  249.         theDepth = 8;
  250.         theMaxDevice = GetMaxDevice(&globRect);
  251.         if (theMaxDevice != nil)
  252.             theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
  253.         }
  254.     
  255.     // allocate the GWorld in temp mem, or local if we run out
  256.     anErr = NewGWorld(&offscreenGWorld, theDepth, 
  257.                         &((PICTDataPtr)pData)->selectionRectangle,
  258.                         nil, nil, useTempMem);
  259.     if (anErr != noErr)
  260.         anErr = NewGWorld(&offscreenGWorld, theDepth, 
  261.                             &((PICTDataPtr)pData)->selectionRectangle,
  262.                             nil, nil, 0);
  263.     nrequire(anErr, FailedNewGWorld);
  264.  
  265.     // blow open the visRgn, and clip to the selected area
  266.     RectRgn(offscreenGWorld->visRgn, &globRect);
  267.     PortChanged((GrafPtr) offscreenGWorld);
  268.     SetGWorld(offscreenGWorld, nil);
  269.     EraseRect(&offscreenGWorld->portRect);
  270.     ClipRect(&((PICTDataPtr)pData)->selectionRectangle);
  271.     
  272.     // Draw the picture into the offscreen
  273.     LockPixels( GetGWorldPixMap(offscreenGWorld));
  274.     {
  275.     Point    offset = {0,0};
  276.     anErr = DiskPictureDraw(pData, true, false, &offset);
  277.     }
  278.     UnlockPixels( GetGWorldPixMap(offscreenGWorld));
  279.     nrequire(anErr, FailedDraw);
  280.  
  281.     // CopyBits in place to grab the selection
  282.     scrapPict = OpenPicture(&((PICTDataPtr)pData)->selectionRectangle);
  283.     LockPixels( GetGWorldPixMap(offscreenGWorld));
  284.     CopyBits(&((GrafPtr)offscreenGWorld)->portBits, &((GrafPtr)offscreenGWorld)->portBits, 
  285.         &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->selectionRectangle,
  286.         srcCopy, nil);
  287.     anErr = QDError();
  288.     UnlockPixels( GetGWorldPixMap(offscreenGWorld));
  289.     ClosePicture();
  290.     globRect = (**scrapPict).picFrame;
  291.     if ( (anErr == noErr) && (EmptyRect(&globRect)) )
  292.         anErr = memFullErr;
  293.         
  294.     // done with our offscreen now
  295.     SetGWorld(savedPort, savedGDevice);
  296.     DisposeGWorld(offscreenGWorld);
  297.  
  298.     if (anErr == noErr)
  299.         *pResult = scrapPict;
  300.     
  301.     return(anErr);
  302.     
  303. // EXCEPTION HANDLING
  304. FailedDraw:
  305.     DisposeGWorld(offscreenGWorld);
  306.     
  307. FailedNewGWorld:
  308.  
  309.     SetGWorld(savedPort, savedGDevice);
  310.     return(anErr);
  311.     
  312. } // GetSelectedPicture
  313.  
  314. // --------------------------------------------------------------------------------------------------------------
  315. static OSErr CopyGWorld(WindowDataPtr pData)
  316. {
  317.     OSErr        anErr;
  318.     PicHandle    scrapPict;
  319.  
  320.     anErr = GetSelectedPicture(pData, &scrapPict);
  321.  
  322.     if (anErr == noErr)
  323.         {
  324.         if (LoadScrap() == noErr)
  325.             {
  326.             ZeroScrap();
  327.             HLock((Handle) scrapPict);
  328.             anErr = PutScrap(GetHandleSize((Handle) scrapPict), 'PICT', (Ptr)*scrapPict);
  329.             KillPicture(scrapPict);
  330.             }
  331.         }
  332.     
  333.     return(anErr);
  334.     
  335. } // CopyGWorld
  336.  
  337. // --------------------------------------------------------------------------------------------------------------
  338. static pascal OSErr PICTSendDataProc(FlavorType theType, void *dragSendRefCon,
  339.                                 ItemReference theItem, DragReference theDrag)
  340. /*
  341.  *    The ItemReference is the gxShape to be sent. The dragSendRefCon is ignored.
  342. */
  343. {
  344. #pragma unused (dragSendRefCon)
  345.  
  346.     OSErr    result = noErr;
  347.  
  348.     switch (theType) 
  349.         {
  350.         case 'PICT':
  351.             {    
  352.             PicHandle     pict;
  353.             OSErr        anErr = GetSelectedPicture((WindowDataPtr)theItem, &pict);
  354.     
  355.             if (anErr == noErr)
  356.                 {    
  357.                 HLock((Handle)pict);
  358.                 result = SetDragItemFlavorData(theDrag, theItem, 'PICT', (Ptr)*pict, GetHandleSize((Handle)pict), 0);
  359.                 KillPicture(pict);
  360.                 }
  361.             }
  362.             break;
  363.             
  364.         default:
  365.             result = badDragFlavorErr;
  366.             break;
  367.         }
  368.         
  369.     return result;
  370.     
  371. } // PICTSendDataProc
  372.  
  373.  
  374. #if GENERATINGCFM
  375.     static RoutineDescriptor gPICTSendDataProcRD = BUILD_ROUTINE_DESCRIPTOR(uppDragSendDataProcInfo, PICTSendDataProc);
  376.     static DragSendDataUPP gPICTSendDataProc = &gPICTSendDataProcRD;
  377. #else
  378.     static DragSendDataUPP gPICTSendDataProc = NewDragSendDataProc(PICTSendDataProc);
  379. #endif
  380.  
  381. // --------------------------------------------------------------------------------------------------------------
  382. // OOP INTERFACE ROUTINES
  383. // --------------------------------------------------------------------------------------------------------------
  384.  
  385. static OSErr    PICTUpdateWindow(WindowRef pWindow, WindowDataPtr pData)
  386. {
  387.     OSErr        anErr;
  388.     RgnHandle    oldClip = NewRgn();
  389.     
  390.     EraseRect(&pData->contentRect);
  391.     
  392.     GetClip(oldClip);
  393.     ClipRect(&pData->contentRect);
  394.     anErr = DiskPictureDraw( pData, true, nil, nil);
  395.     SetClip(oldClip);
  396.     DisposeRgn(oldClip);
  397.     
  398.     DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, false);
  399.     
  400.     DrawControls(pWindow);
  401.     DrawGrowIcon(pWindow);
  402.     
  403.     return(anErr);
  404.     
  405. } // PICTUpdateWindow
  406.  
  407. // --------------------------------------------------------------------------------------------------------------
  408.  
  409. static OSErr    PICTGetDocumentRect(WindowRef pWindow, WindowDataPtr pData, 
  410.             LongRect * documentRectangle, Boolean forGrow)
  411. {
  412. #pragma unused (pWindow, forGrow)
  413.  
  414.     RectToLongRect(&((PICTDataPtr)pData)->pictureRectangle, documentRectangle);
  415.     
  416.     return(noErr);
  417.     
  418. } // PICTGetDocumentRect
  419.  
  420. // --------------------------------------------------------------------------------------------------------------
  421.  
  422. static OSErr    PICTCloseWindow(WindowRef pWindow, WindowDataPtr pData)
  423. {
  424. #pragma unused (pWindow)
  425.  
  426.     DisposeHandle( (Handle) (((PICTDataPtr)pData)->cacheHandle));
  427.     
  428.     return(noErr);
  429.     
  430. } // PICTCloseWindow
  431.  
  432. // --------------------------------------------------------------------------------------------------------------
  433.  
  434. static OSErr    PICTContentClick(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent)
  435. {
  436.     OSErr    anErr = noErr;
  437.     Rect    selectionRect = ((PICTDataPtr)pData)->selectionRectangle;
  438.     Point    clickPoint = pEvent->where;
  439.     
  440.     GlobalToLocal(&clickPoint);
  441.     OffsetRect(&selectionRect, -GetControlValue(pData->hScroll), -GetControlValue(pData->vScroll));
  442.     if ( (gMachineInfo.haveDragMgr) && (PtInRect(clickPoint, &selectionRect)) )
  443.         {
  444.         DragAndDropArea(pWindow, pData, pEvent, 
  445.                             &selectionRect);
  446.         }
  447.     else
  448.         {
  449.         anErr = SelectContents(pWindow, pData, pEvent, 
  450.                     &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->pictureRectangle, 
  451.                     &((PICTDataPtr)pData)->patternPhase);
  452.         }
  453.     
  454.     return(anErr);
  455.     
  456. } // PICTContentClick
  457.  
  458. // --------------------------------------------------------------------------------------------------------------
  459.  
  460. static OSErr    PICTAdjustCursor(WindowRef pWindow, WindowDataPtr pData, Point * localMouse, Rect * globalRect)
  461. {
  462. #pragma unused (pWindow, globalRect)
  463.  
  464.     OSErr            anErr = noErr;
  465.     CursHandle        theCross;
  466.     Rect            selectionRect = ((PICTDataPtr)pData)->selectionRectangle;
  467.     
  468.     OffsetRect(&selectionRect, -GetControlValue(pData->hScroll), -GetControlValue(pData->vScroll));
  469.     if (!PtInRect(*localMouse, &selectionRect) )
  470.         {
  471.         theCross = GetCursor(crossCursor);
  472.         if (theCross)
  473.             {
  474.             char    oldState;
  475.             
  476.             oldState = HGetState((Handle) theCross);
  477.             HLock((Handle) theCross);
  478.             SetCursor(*theCross);
  479.             HSetState((Handle) theCross, oldState);
  480.             anErr = eActionAlreadyHandled;
  481.             }
  482.         }    
  483.         
  484.     return(anErr);
  485.     
  486. } // PICTAdjustCursor
  487.  
  488. // --------------------------------------------------------------------------------------------------------------
  489.  
  490. static OSErr    PICTDragAddFlavors(WindowRef pWindow, WindowDataPtr pData, DragReference theDragRef)
  491. {
  492. #pragma unused (pWindow)
  493.  
  494.     OSErr    anErr = noErr;
  495.     
  496.     SetDragSendProc(theDragRef, gPICTSendDataProc, nil);
  497.     AddDragItemFlavor(theDragRef, (unsigned long)pData, 'PICT', nil, 0, 0);
  498.     
  499.     return(anErr);
  500.     
  501. } // PICTDragAddFlavors
  502.  
  503. // --------------------------------------------------------------------------------------------------------------
  504.  
  505. static OSErr    PICTGetBalloon(WindowRef pWindow, WindowDataPtr pData, 
  506.         Point *localMouse, short * returnedBalloonIndex, Rect *returnedRectangle)
  507. {
  508. #pragma unused (pWindow, pData)
  509.  
  510.     Rect    tempRect = ((PICTDataPtr)pData)->selectionRectangle;
  511.     
  512.     // assume generic content
  513.     *returnedBalloonIndex = iHelpPictContent;
  514.     
  515.     // see if we are within the selection
  516.     OffsetRect(&tempRect, -GetControlValue(pData->hScroll), -GetControlValue(pData->vScroll) );
  517.     SectRect(&tempRect, &pData->contentRect, &tempRect);
  518.     
  519.     if (PtInRect(*localMouse, &tempRect))
  520.         {
  521.         *returnedRectangle        = tempRect;
  522.         *returnedBalloonIndex     = iHelpPictSelection;
  523.         }
  524.         
  525.     return(noErr);
  526.     
  527. } // PICTGetBalloon
  528.  
  529. // --------------------------------------------------------------------------------------------------------------
  530.  
  531. static OSErr    PICTPrintPage(WindowRef pWindow, WindowDataPtr pData,
  532.                     Rect * pageRect, long *pageNum)
  533. {
  534. #pragma unused (pWindow)
  535.  
  536.     OSErr    anErr = noErr;
  537.     short    pagesWide, pagesHigh;
  538.     Rect    pictureRect = ((PICTDataPtr)pData)->pictureRectangle;
  539.     Point    offset;
  540.     Rect    localPageRect = *pageRect;
  541.     
  542.     // calculate how many physical pages will be required to print this PICT
  543.     if (EqualRect(&pictureRect, &localPageRect))
  544.         pagesWide = pagesHigh = 1;
  545.     else
  546.         {
  547.         pagesWide = (pictureRect.right - pictureRect.left) / (localPageRect.right - localPageRect.left) + 1;
  548.         pagesHigh = (pictureRect.bottom - pictureRect.top) / (localPageRect.bottom - localPageRect.top) + 1;
  549.         }
  550.                     
  551.     // compute the offset in # of pages
  552.     offset.h = ((*pageNum - 1) % pagesWide);
  553.     offset.v = ((*pageNum - 1) / pagesWide);
  554.  
  555.     // compute the pixel offset for this page
  556.     offset.h *= localPageRect.right - localPageRect.left;
  557.     offset.v *= localPageRect.bottom - localPageRect.top;
  558.     
  559.     anErr = DiskPictureDraw( pData, true, &localPageRect, &offset);
  560.     
  561.     // tell it to stop printing when we reach the end
  562.     if (*pageNum >= (pagesWide*pagesHigh))
  563.         *pageNum = -1;
  564.     
  565.     return(anErr);
  566.     
  567. } // PICTPrintPage
  568.  
  569. // --------------------------------------------------------------------------------------------------------------
  570.  
  571. static OSErr    PICTAdjustMenus(WindowRef pWindow, WindowDataPtr pData)
  572. {
  573. #pragma unused (pWindow)
  574.  
  575.     OSErr anErr = noErr;
  576.     
  577.     if (!EmptyRect(&((PICTDataPtr)pData)->selectionRectangle))
  578.         EnableCommand(cCopy);
  579.  
  580.     if     (EqualRect(&((PICTDataPtr)pData)->pictureRectangle, &((PICTDataPtr)pData)->selectionRectangle))
  581.         ChangeCommandName(cSelectAll, kMiscStrings, iSelectNoneCommand);
  582.     else
  583.         ChangeCommandName(cSelectAll, kMiscStrings, iSelectAllCommand);
  584.     EnableCommand(cSelectAll);
  585.     
  586.     return(anErr);
  587.     
  588. } // PICTAdjustMenus
  589.  
  590. // --------------------------------------------------------------------------------------------------------------
  591.  
  592. static OSErr    PICTCommand(WindowRef pWindow, WindowDataPtr pData, short commandID, long menuResult)
  593. {
  594. #pragma unused (pWindow, menuResult)
  595.  
  596.     OSErr    anErr = noErr;
  597.     
  598.     switch (commandID)
  599.         {
  600.         case cCopy:
  601.             anErr = CopyGWorld(pData);
  602.             break;
  603.         
  604.         case cSelectAll:
  605.             // erase the old selection
  606.             DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, false);
  607.             
  608.             if     (EqualRect(&((PICTDataPtr)pData)->pictureRectangle, &((PICTDataPtr)pData)->selectionRectangle))
  609.                 {
  610.                 ((PICTDataPtr)pData)->selectionRectangle.top = 0;
  611.                 ((PICTDataPtr)pData)->selectionRectangle.left = 0;
  612.                 ((PICTDataPtr)pData)->selectionRectangle.bottom = 0;
  613.                 ((PICTDataPtr)pData)->selectionRectangle.right = 0;
  614.                 }
  615.             else
  616.                 {
  617.                 ((PICTDataPtr)pData)->selectionRectangle = ((PICTDataPtr)pData)->pictureRectangle;
  618.                 }
  619.                 
  620.             // draw the new selection
  621.             DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, true);
  622.             break;
  623.         }
  624.     
  625.     return(anErr);
  626.     
  627. } // PICTCommand
  628.  
  629. // --------------------------------------------------------------------------------------------------------------
  630.  
  631. static long PICTCalculateIdleTime(WindowRef pWindow, WindowDataPtr pData)
  632. {
  633. #pragma unused (pWindow)
  634.  
  635.     if (!EmptyRect( &((PICTDataPtr)pData)->selectionRectangle))
  636.         return(0);
  637.     else
  638.         return(kMaxWaitTime);
  639.         
  640. } // PICTCalculateIdleTime
  641.  
  642. // --------------------------------------------------------------------------------------------------------------
  643.  
  644. static Boolean    PICTFilterEvent(WindowRef pWindow, WindowDataPtr pData, EventRecord *pEvent)
  645. {
  646.     if     (
  647.         (!gMachineInfo.amInBackground) &&
  648.         (pEvent->what == nullEvent) &&
  649.         (pWindow == FrontWindow()) &&
  650.         (EmptyRgn( ((WindowPeek)pWindow)->updateRgn)) &&
  651.         (MOVESELECTION(pEvent->when) )
  652.         )
  653.         {
  654.         // erase the old
  655.         DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, false);
  656.         
  657.         // draw the new, moving onto the next pattern
  658.         DrawSelection(pData, &((PICTDataPtr)pData)->selectionRectangle, &((PICTDataPtr)pData)->patternPhase, true);
  659.         }
  660.         
  661.     return(false);
  662.     
  663. } // PICTFilterEvent
  664.  
  665. // --------------------------------------------------------------------------------------------------------------
  666.  
  667. static OSErr    PICTMakeWindow(WindowRef pWindow, WindowDataPtr pData)
  668. {
  669. #pragma unused (pWindow)
  670.  
  671.     Size    availableRAM;
  672.     long    amountInFile;
  673.     OSErr    anErr = noErr;
  674.     
  675.     pData->pUpdateWindow         = (UpdateWindowProc)        PICTUpdateWindow;
  676.     pData->pGetDocumentRect     = (GetDocumentRectProc)        PICTGetDocumentRect;
  677.     pData->pCloseWindow         = (CloseWindowProc)            PICTCloseWindow;
  678.     pData->pContentClick         = (ContentClickProc)        PICTContentClick;
  679.     pData->pAdjustCursor         = (AdjustCursorProc)        PICTAdjustCursor;
  680.     pData->pGetBalloon             = (GetBalloonProc)            PICTGetBalloon;
  681.     pData->pAdjustMenus         = (AdjustMenusProc)            PICTAdjustMenus;
  682.     pData->pPrintPage             = (PrintPageProc)            PICTPrintPage;
  683.     pData->pCommand                 = (CommandProc)                PICTCommand;
  684.     pData->pFilterEvent             = (FilterEventProc)            PICTFilterEvent;
  685.     pData->pCalculateIdleTime    = (CalculateIdleTimeProc)    PICTCalculateIdleTime;
  686.     pData->pDragAddFlavors        = (DragAddFlavorsProc)        PICTDragAddFlavors;
  687.     
  688.     pData->hasGrow                = true;
  689.     pData->hScrollAmount        = 10;
  690.     pData->vScrollAmount        = 10;
  691.     
  692.     // Calculate amount of available RAM for cache
  693.     {
  694.     Size grow;
  695.     availableRAM = MaxMem(&grow);
  696.     }
  697.     
  698.     // Take half of it
  699.     availableRAM >>= 1;
  700.     
  701.     // if too big, make it just big enough
  702.     GetEOF(pData->dataRefNum, &amountInFile);
  703.     amountInFile -= 512;
  704.     
  705.     if (amountInFile < sizeof(Picture))
  706.         anErr = eErrorWhileDrawing;
  707.     else
  708.         {
  709.         if (availableRAM > amountInFile)
  710.             {
  711.             Handle    theHandle = NewHandle(amountInFile);
  712.             
  713.             if (theHandle)
  714.                 {
  715.                 SetFPos(pData->dataRefNum, fsFromStart, 512);
  716.                 FSRead(pData->dataRefNum, &amountInFile, *theHandle);
  717.                 
  718.                 ((PICTDataPtr)pData)->cacheHandle = (PicHandle)theHandle;
  719.                 }
  720.             }
  721.             
  722.         // initialize the rectangle to be valid
  723.         {
  724.         Rect    pictureRect;
  725.  
  726.         DiskPictureDraw( pData, false, &((PICTDataPtr)pData)->pictureRectangle, nil);
  727.     
  728.         pictureRect = ((PICTDataPtr)pData)->pictureRectangle;
  729.         if ((pData->contentRect.right > pictureRect.right) && (pictureRect.right > 0))
  730.             pData->contentRect.right = pictureRect.right;
  731.         if ((pData->contentRect.bottom > pictureRect.bottom) && (pictureRect.bottom > 0))
  732.             pData->contentRect.bottom = pictureRect.bottom;
  733.         }
  734.         }
  735.     
  736.     return(anErr);
  737.     
  738. } // PICTMakeWindow
  739.  
  740.  
  741. // --------------------------------------------------------------------------------------------------------------
  742.  
  743. OSErr    PICTPreflightWindow(PreflightPtr pPreflightData)
  744. {
  745.     pPreflightData->wantHScroll            = true;
  746.     pPreflightData->wantVScroll            = true;
  747.     
  748.     pPreflightData->continueWithOpen     = true;
  749.     pPreflightData->makeProcPtr         = PICTMakeWindow;
  750.     
  751.     pPreflightData->storageSize = sizeof(PICTDataRecord);
  752.     
  753.     return(noErr);
  754.     
  755. } // PICTPreflightWindow
  756.  
  757. // --------------------------------------------------------------------------------------------------------------
  758.  
  759. void PICTGetFileTypes(OSType * pFileTypes, OSType * pDocumentTypes, short * numTypes)
  760. {
  761.     pFileTypes[*numTypes]         = 'PICT';
  762.     pDocumentTypes[*numTypes]     = kPICTWindow;
  763.     (*numTypes)++;
  764.     
  765. } // PICTGetFileTypes
  766.